import org.junit.Test;

import java.util.Arrays;

/**
 * 程序只有一个入口：main方法   程序入口
 * 理解：类中只有一个主方法
 *
 * 类中多个1类似主方法：单元测试  junit.4【外置jar包】
 *                 jar  别人写好的类 直接使用
 *            单元测试：专门测试功能模块
 *            单元测试的步骤
 *            1.编写一个注解      @Test  编写单元测试
 *            2.编写方法     修饰符    返回值  方法名（）{}
 *
 *
 */


public class 基础语法 {
    /**
     * float  单精度 不常用 4字节 取小数点后6位有效数
     * 写法：float 标识符=字面量F/f；
     */
    @Test
    public void basic(){
        float pi=3.1415926535F;
        System.out.println(pi);  //3.1415927
        int a=128+256; //00000000 00000000 00000001 10000000
        byte b=(byte)a; //砍掉前24位 剩余部分10000000
        System.out.println(b); //-128
     //   int _123F=1;
          String name="yanyan";
          int age=18;
        System.out.println(name+age);
    }
    /**
     * 数组  Array   引用类型     对象 通过new创建
     * 数组相当于一推相同“数据”集合
     * 单元测试1.testArrog   创建数组的方式以及初始化
     *
     */
    @Test
    public void testArray(){
        //创建一个arr空数组 长度为4
        int[] arr=new int[4];  //动态初始化：指定空间 并且按照空间分元素
        int[] arr1={1,2,3};//静态初始化：直接给定值
        System.out.println(arr1[1]);
        int arr2[]=new int[4];//动态初始化：指定空间 并且按照空间分元素
        int[] arr3=new int[]{1,2,3};//动态初始化：指定空间 并且按照空间分元素
        //从arr1静态初始化的数组获取 2 元素 数组名  下标

        //从arr1 静态初始化数组获取   长度
        System.out.println(arr1.length);  //输出3
        //从arr1 获取下标为4的值   输出什么  数组下标越界异常
        System.out.println(arr1[4]);

    }

    /**
     * 数组遍历【3种迭代方式】
     * 1.普遍for jdk1.5之前使用
     * 2.增强for jdk1.5之后使用  推荐
     * 3.工具类   推荐
     */
   @Test
    public void testIterate(){
       int[] arr={1,2,3,4}; //静态数组
 //      for (int i=0;i<arr.length;i++){  //获取数组的下标
   //        System.out.println(arr[i]);

     //  }
       //遍历数据类型  引用名：数组名
      // for (int i:arr){//直接打印元素值
        //   System.out.println(i);
      // }
       //工具类    toString方法 打印所有数组元素
       System.out.println(Arrays.toString(arr));
   }
    /**
     * 数组的扩容
     * Java数组对象大小是固定的  数组对象不可以扩展的
     * 使用数据扩容方式变通
     * Arrays.copyOf（） 方法创建数组副本
     */
   @Test
    public void testCopy(){
       char[] arr={'唐','山'};   //定义数组 ，长度固定   2个
       //使用Arrays提供copyOf方法创建当前数组的副本
       char[] temp=Arrays.copyOf(arr,4);
       //副本  复制给 不可改变的数组
       char[] tarr=temp;
       System.out.println(tarr);  // 唐    山  /u0000 /u0000
       tarr[2]='工';
       tarr[3]='业';
       System.out.println(tarr);
   }
    /**
     * 拓展：数组输出，根据数据类型不同，输出效果不同【看】
     * 数组语法
     * 数组类型[] 数组名=new 数据类型【】；
     * 数据类型：基础数据类型+引用类型
     * 创建数据根据数据类型 明确是什么类型
     */
    @Test
    public void testLook(){
        //字符数组---输出方式
        char[] china={'中','国'};
        System.out.println(china);  //输出   中国
        //Javaoop  面向对象知识点：数组输出方法提供重载功能  字符数组 优化为字符串
        //常规数组输出效果  Arrays工具类 toString方法：打印数组
        System.out.println(Arrays.toString(china));

        //数值数组
        int[] i={1,2};
        System.out.println(i);   //
        //查看数组输出效果
        System.out.println(Arrays.toString(i));
    }
    /**
     * 数组经典案例：
     * int[] arr={3,6,4,1}
     * 数组元素排序：升序 降序
     * 面试题：上述数组按照升序方式排序
     * 解题思路三种方案：选择排序 冒泡排序 插入排序
     * 冒泡排序：双层for循环使用 比较相邻的元素 将元素数组小的值放到前面
     */
    @Test
    public void bubbleSort(){
        int[] arr={3,6,4,1};  //静态数组
        //  for   外层循环【轮】+for    内层   循环【次】
        //  考虑 ：每一轮需要比较几次

        for (int i=0;i<arr.length;i++){   //外层for：控制比较轮
           for (int j=0;i<arr.length-1-i;j++){  //内层for：两两比较
               //交换  升序：从小到大    第一个值>第二个值   成立  交换
               if(arr[j]>arr[j+1]){      //第一个值：元素数arr【j】  第二个值：元素值arr【j+1】
                   //交换：第三方数组变量   交换数组名temp
                   int temp=arr[j];  //第一个值交给第三方数组变量
                   arr[j]=arr[j+1];  //第二个值交给第一个值
                   arr[j+1]=temp;  //第三方变量交给第二个值
               }

           }
        }
        System.out.println(Arrays.toString(arr));
    }

   @Test
    public void sort(){
         int[] arr={3,6,4,1};
         //工具类：提供sort（）排序方法
       Arrays.sort(arr);  //默认 升序
       System.out.println(Arrays.toString(arr));

   }

}
